//系统主类实现
#include "robot_system.h"
#include "secure_comm.h"
#include "user_manager.h"
#include "debug_visualizer.h"
#include "simulation_engine.h"
#include "security_logger.h"
#include <QThread>
#include <QTimer>

RobotSystem::RobotSystem(QObject *parent) 
    : QObject(parent)
    , user_manager_(std::make_unique<UserManager>())
    , comm_manager_(std::make_unique<SecureCommManager>())
    , visualizer_(std::make_unique<DebugVisualizer>())
    , simulation_engine_(std::make_unique<SimulationEngine>())
    , security_logger_(std::make_unique<SecurityLogger>())
{
    // 初始化日志记录
    security_logger_->init("logs/robot_system.log");
    emit debugLog("RobotSystem 实例创建成功");
}

RobotSystem::~RobotSystem() {
    stop();
    emit debugLog("RobotSystem 实例销毁");
}

// 系统初始化（初始化通信、用户管理、仿真等模块）
bool RobotSystem::initialize(int port, const std::string& cert_path, const std::string& key_path) {
    control_port_ = port;
    ssl_cert_path_ = cert_path;
    ssl_key_path_ = key_path;

    // 1. 初始化通信模块
    if (!comm_manager_->init(port, cert_path, key_path)) {
        emit debugLog("通信模块初始化失败（端口/证书错误）", Qt::red);
        security_logger_->logError("SecureCommManager init failed: port=" + std::to_string(port));
        return false;
    }

    // 2. 初始化用户管理（加载默认用户）
    if (!user_manager_->loadUsers("config/users.json")) {
        emit debugLog("用户管理模块初始化失败（加载用户配置错误）", Qt::red);
        security_logger_->logError("UserManager loadUsers failed");
        return false;
    }

    // 3. 初始化仿真模块
    simulation_engine_->init();

    // 4. 绑定通信模块信号（接收外部命令）
    connect(comm_manager_.get(), &SecureCommManager::commandReceived, 
            this, &RobotSystem::sendCommand);

    emit debugLog("系统初始化成功，端口：" + QString::number(port));
    security_logger_->logInfo("System initialized successfully, port=" + std::to_string(port));
    return true;
}

// 启动系统（启动通信监听、状态更新线程）
void RobotSystem::start() {
    if (is_running_) {
        emit debugLog("系统已处于运行状态，无需重复启动");
        return;
    }

    is_running_ = true;

    // 1. 启动通信模块监听
    comm_manager_->startListen();

    // 2. 启动状态更新定时器（100ms更新一次状态）
    QTimer* state_timer = new QTimer(this);
    state_timer->setInterval(100);
    connect(state_timer, &QTimer::timeout, this, [this]() {
        RobotState current_state;
        if (is_simulation_mode_) {
            // 仿真模式：从仿真引擎获取状态
            current_state = simulation_engine_->getCurrentState();
        } else {
            // 实际模式：从硬件获取状态（此处暂用仿真数据占位，需替换为硬件通信逻辑）
            current_state = simulation_engine_->getCurrentState();
        }

        // 推送状态到可视化界面和外部客户端
        emit stateUpdated(current_state);
        comm_manager_->sendState(current_state);
    });
    state_timer->start();

    emit debugLog("系统启动成功，仿真模式：" + QString(is_simulation_mode_ ? "开启" : "关闭"));
    security_logger_->logInfo("System started, simulation_mode=" + std::to_string(is_simulation_mode_));
}

// 停止系统（停止所有模块）
void RobotSystem::stop() {
    if (!is_running_) return;

    is_running_ = false;

    // 停止通信监听
    comm_manager_->stopListen();

    // 停止仿真
    simulation_engine_->stop();

    // 停止定时器（避免内存泄漏）
    for (auto timer : findChildren<QTimer*>()) {
        timer->stop();
        timer->deleteLater();
    }

    emit debugLog("系统停止成功", Qt::darkGreen);
    security_logger_->logInfo("System stopped");
}

// 发送控制命令（处理运动、启停等命令）
void RobotSystem::sendCommand(const ControlCommand& cmd) {
    if (!is_running_) {
        emit debugLog("系统未运行，无法执行命令：" + QString::fromStdString(cmd.cmd_name), Qt::red);
        return;
    }

    // 1. 权限校验（检查当前用户是否有权限执行该命令）
    auto current_user = user_manager_->getCurrentUser();
    if (!current_user || !current_user->hasPermission(cmd.perm_mask)) {
        emit debugLog("权限不足，无法执行命令：" + QString::fromStdString(cmd.cmd_name), Qt::red);
        security_logger_->logWarn("Permission denied: cmd=" + cmd.cmd_name + ", user=" + current_user->username);
        return;
    }

    // 2. 执行命令（根据命令类型分发到仿真/硬件模块）
    bool cmd_success = false;
    std::string cmd_result = "unknown error";

    if (is_simulation_mode_) {
        // 仿真模式：发送命令到仿真引擎
        std::tie(cmd_success, cmd_result) = simulation_engine_->executeCommand(cmd);
    } else {
        // 实际模式：发送命令到硬件（此处暂用仿真逻辑占位）
        std::tie(cmd_success, cmd_result) = simulation_engine_->executeCommand(cmd);
    }

    // 3. 反馈命令执行结果
    if (cmd_success) {
        emit debugLog("命令执行成功：" + QString::fromStdString(cmd.cmd_name) + "，结果：" + QString::fromStdString(cmd_result), Qt::darkGreen);
        security_logger_->logInfo("Command executed: cmd=" + cmd.cmd_name + ", result=" + cmd_result);
    } else {
        emit debugLog("命令执行失败：" + QString::fromStdString(cmd.cmd_name) + "，原因：" + QString::fromStdString(cmd_result), Qt::red);
        security_logger_->logError("Command failed: cmd=" + cmd.cmd_name + ", reason=" + cmd_result);
    }

    // 4. 向客户端反馈执行结果
    comm_manager_->sendCommandResponse(cmd.cmd_id, cmd_success, cmd_result);
}

// 获取可视化界面
DebugVisualizer* RobotSystem::getVisualizer() const {
    return visualizer_.get();
}

// 切换仿真模式
void RobotSystem::setSimulationMode(bool enabled) {
    if (is_running_ && is_simulation_mode_ != enabled) {
        is_simulation_mode_ = enabled;
        emit debugLog("仿真模式切换：" + QString(enabled ? "开启" : "关闭"), Qt::blue);
        security_logger_->logInfo("Simulation mode changed: " + std::to_string(enabled));
    }
}

bool RobotSystem::isSimulationMode() const {
    return is_simulation_mode_;
}